//
//                       _oo0oo_
//                      o8888888o
//                      88" . "88
//                      (| -_- |)
//                      0\  =  /0
//                    ___/`---'\___
//                  .' \\|     |// '.
//                 / \\|||  :  |||// \
//                / _||||| -:- |||||- \
//               |   | \\\  -  /// |   |
//               | \_|  ''\---/''  |_/ |
//               \  .-\__  '-'  ___/-. /
//             ___'. .'  /--.--\  `. .'___
//          ."" '<  `.___\_<|>_/___.' >' "".
//         | | :  `- \`.;`\ _ /`;.`/ - ` : | |
//         \  \ `_.   \_ __\ /__ _/   .-` /  /
//     =====`-.____`.___ \_____/___.-`___.-'=====
//                       `=---='
//
//
//     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//                   好人一生平安


import java.util.EmptyStackException;
import java.util.Scanner;
import java.util.Stack;


public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String input = in.nextLine();
        input = input.replace(" ", ""); // 表达式
        Stack<Integer> numStack = new Stack<Integer>(); // 数值栈
        Stack<Character> opStack = new Stack<Character>(); // 运算符栈
        int num = 0; // 生成操作数
        int sign = 1; //正负号
        boolean flag = false; // 是否有操作数生成
        try {
            for (int i = 0;i < input.length();i++) {
                // 数字字符更新操作数
                if ('0' <= input.charAt(i) && input.charAt(i) <= '9') {
                    num = num * 10 + input.charAt(i) - '0';
                    flag = true;
                } else {
                    // 运算符字符
                    char c = input.charAt(i);
                    if (flag) {
                        // 操作数入栈
                        numStack.push(num * sign);
                        num = 0;
                        sign = 1;
                        flag = false;
                    }
                    // 判断负号
                    if (c == '-') {
                        if (i == 0 || input.charAt(i - 1) == '(') {
                            sign = -sign;
                            continue;
                        }
                    }
                    // 运算符栈为空则运算符直接入栈
                    if (opStack.isEmpty()) {
                        opStack.push(c);
                    } else {
                        if (c == '(') {
                            // '('运算符直接入栈
                            opStack.push(c);
                        } else if (c == ')') {
                            // 数值栈与运算符栈出栈运算，更新数值栈直到'('运算符出栈
                            while (!opStack.isEmpty() && opStack.peek() != '(') {
                                numStack.push(calculate(numStack.pop(), numStack.pop(), opStack.pop()));
                            }
                            opStack.pop();
                        } else {

                            // 数值栈与运算符栈出栈运算，直到运算符栈栈顶元素优先级低于当前运算符
                            while (!opStack.isEmpty() && (getPRI(opStack.peek()) >= getPRI(c))) {
                                numStack.push(calculate(numStack.pop(), numStack.pop(), opStack.pop()));
                            }
                            // 当前运算符入栈
                            opStack.push(c);
                        }
                    }
                }
            }
            // 如果有最后一个操作数生成，则此操作数入栈
            if ('0' <= input.charAt(input.length() - 1) && input.charAt(input.length() - 1) <= '9')
                numStack.push(num);
            // 两栈出栈运算直到空为止
            while (!opStack.isEmpty()) {
                numStack.push(calculate(numStack.pop(), numStack.pop(), opStack.pop()));
            }
            // 输出结果
            System.out.println(numStack.pop());
            // 有数据残余表示表达式有误
            if (!numStack.isEmpty() || !opStack.isEmpty()) {
                System.out.println("Invalid expression");
            }
        } catch(EmptyStackException e) {
            System.out.println("Invalid Expression");
        }
    }

    // 运算操作，第一个参数为第二操作数，第二个参数为第一操作数
    private static int calculate(int y, int x, char op) {
        int tmp = 0;
        switch (op) {
            case '*':
                tmp = x * y;
                break;
            case '/':
                tmp = x / y;
                break;
            case '%':
                tmp = x % y;
                break;
            case '+':
                tmp = x + y;
                break;
            case '-':
                tmp = x - y;
                break;
            default:
                break;
        }
        return tmp;
    }

    // 优先级设置
    private static int getPRI(char op) {
        int flag = 0;
        switch (op) {
            case '(':
                flag = 0;
                break;
            case '+':
            case '-':
                flag = 1;
                break;
            case '*':
            case '/':
            case '%':
                flag = 2;
                break;
        }
        return flag;
    }
}
